<!DOCTYPE html>
<html lang="en">

<head>
  <meta charset="UTF-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>对象方法扩展</title>
</head>

<body>
  <script>
    // 1. Object.is 判断两个值是否完全相等
    /* console.log(Object.is(120, 120));               // true
    console.log(Object.is(NaN, NaN));               // true
    console.log(NaN === NaN);                       // false
    console.log(Object.is(0, "0"));                 // false
    console.log(0 == "0");                          // true
    console.log(Object.is(null, null));             // true
    console.log(null === null);                     // true
    console.log(Object.is(undefined, undefined));   // true
    console.log(undefined === undefined);           // true */

    // 2. Object.assign 对象的合并
    /* 
      1). 只能复制可枚举的自有属性，无法复制继承属性和不可枚举的属性
      2). 遇到同名的属性，后面的会覆盖之前的
      3). 浅复制，只复制引用对象的地址
      4). Symbol属性也能被复制
      5). 源对象是基本类型的值时，都会被包装成对象，undefined和null没有包装对象，数字和布尔类型不可枚举，故只有字符类型才能转成对象
      6). 源对象的访问器属性会变成目标对象的数据属性，简单说就是 源对象的计算属性会转换成目标对象的普通属性
    */
    const config1 = {
      host: 'localhost',
      port: 3306,
      name: 'root',
      pass: 'root',
      test: '123132'
    }

    const config2 = {
      host: 'http://atguigu.com',
      port: 33060,
      name: 'atguigu.com',
      pass: 'iloveyou',
      test2: 'test2'
    }

    console.log(Object.assign(config1, config2));

    // 1). 只能复制可枚举的自有属性，无法复制继承属性和不可枚举的属性
    var obj1 = {name:"strick"},
        obj2 = Object.create(obj1)              // 继承的属性
        obj2.age = 28
        Object.defineProperty(obj2, "age", {
          enumerable: false                     // 不可枚举的属性
        })

        obj2.school = "university"
        console.log(Object.assign({}, obj2))    // {school: 'university'}

      // 2). 遇到同名的属性，后面的会覆盖之前的
      var obj1 = {name:"strick"},
          obj2 = {name:"freedom"}

          console.log(Object.assign({}, obj1, obj2))  // {name: 'freedom'}

      // 3). 浅复制，只复制引用对象的地址 改一个会影响多个
      var obj1 = {name: {name: "strick"}},
          obj2 = Object.assign({}, obj1)
          obj1.name.name = "freedom"
          console.log(obj1, obj2)                     // name: {name: 'freedom'}

      // 4). Symbol属性也能被复制
      var obj1 = {[Symbol("name")]: "strick"},
          obj2 = Object.assign({}, obj1)
          console.log(obj2)                           // {Symbol(name): 'strick'}

      // 5). 源对象是基本类型的值时，都会被包装成对象，undefined和null没有包装对象，数字和布尔类型不可枚举，故只有字符类型才能转成对象
      var obj = Object.assign({}, 1, "a", true, undefined, null)
      console.log(obj)                                // {0: 'a'}

      // 6). 源对象的访问器属性会变成目标对象的数据属性，简单说就是 源对象的计算属性会转换成目标对象的普通属性
      var obj = {
        get name() {
          return "strick"
        }
      }

      console.log(Object.assign({}, obj))             // {name: 'strick'}


    // 3. Object.setPrototypeOf 设置原型对象 Object.getPrototypeOf
    const school = {
      name: '尚硅谷'
    }

    const cities = {
      xiaoqu: ['北京', '上海', '深圳']
    }

    // Object.setPrototypeOf(待修改的对象, 新的原型对象);
    Object.setPrototypeOf(school, cities);
    console.log(school);
    console.log(Object.getPrototypeOf(school))

    // 4. Object.is()  判断两个值是否相同
    console.log(NaN === NaN)          // false
    console.log(Object.is(NaN, NaN))  // true
    console.log(+0 === -0)            // true
    console.log(Object.is(+0 === -0)) // false

  </script>
</body>

</html>